Software developers are often tasked with maintaining existing software applications or systems by adding new functionality or fixing bugs (e.g., defects) within software code that provides existing functionality. As a development project proceeds in time, the amount and frequency of changes may increase. Such changes can be considered to increase the “entropy” of the software. As software entropy increases, the design structure of the software becomes more complex, which may result in an increase in the number of failures associated with the software. Testing and validation operations can be performed on software to detect software defects before product launch. However, some failures may arise due to interoperability faults between multiple software modules that, individually, do not exhibit any apparent defects.
Software modules can be configured to dynamically respond to the runtime occurrence of some errors or faults via an exception handling system. An exception is an anomalous or exceptional condition that may require special handling by the software module. Such special handling can include changing the flow of program execution to run a specific set of software routines that are associated with the occurrence of a specific exception. The specific type of error or exception handling that is implemented within a software module can vary based on the underlying programming language and programming module in use.
Error and exception handling in library-based applications has historically been restricted to using only design-time techniques that make use of explicitly defined exception declarations. A developer with knowledge of a potential error or exception can include software instructions to identify and raise potential exceptions, with additional software instructions that can catch and handle such exceptions. However, with the introduction of service-oriented technologies, including micro-services, continuous integration (CI), continuous delivery (CD), containerization, virtualization, and cloud-computing, applications are increasingly being developed as application services that are compositions of local software and distributed services. Such complex systems can make the design-time error and exception handling techniques insufficient to anticipate the many types of errors and exceptions that may occur at runtime.